#include "libPFS.h"

void
unirNombreLargo (stLongFileName stArchivosNombreLargo, uint16_t **nombreUnido)
{
  int16_t offset = 0;
  int16_t tamParcial = 0;

  tamParcial = sizeof (stArchivosNombreLargo.LFN_NombreParte1) / 2;
  memcpy(*nombreUnido , stArchivosNombreLargo.LFN_NombreParte1 ,
      tamParcial * sizeof(uint16_t));
  offset += tamParcial;
  tamParcial = sizeof (stArchivosNombreLargo.LFN_NombreParte2) / 2;
  memcpy(*nombreUnido + offset , stArchivosNombreLargo.LFN_NombreParte2 ,
      tamParcial * sizeof(uint16_t));
  offset += tamParcial;
  tamParcial = sizeof (stArchivosNombreLargo.LFN_NombreParte3) / 2;
  memcpy(*nombreUnido + offset , stArchivosNombreLargo.LFN_NombreParte3 ,
      tamParcial * sizeof(uint16_t));

}
uint8_t
armarNombreLargo (stLongFileName stArchivosNombreLargo, char **nombreLargo)
{
  uint16_t *nombreUnido;
  nombreUnido = ( uint16_t *) calloc(13 , sizeof(uint16_t));
  unirNombreLargo(stArchivosNombreLargo , &nombreUnido);
  int16_t recorroNombre = 0, bool = 0;
  char letra;
  while (bool == 0 && recorroNombre < 13)
    {
      if (* (nombreUnido + recorroNombre) == 0)
        bool = 1;
      memcpy(&letra , nombreUnido + recorroNombre , sizeof(char));
      * (*nombreLargo + recorroNombre) = letra;
      recorroNombre++;
    }
  free(nombreUnido);
  return recorroNombre;
}

/* Estructura Para Almacenar el Nombre (Largo o Corto y una Directory Table */
void
cargarNombreLargo (stLongFileName *stNombreLargoAEscribir,
    char *directorioACrear)
{
  char letra;
  uint8_t bool = 0;
  uint8_t recorroNombre = 0;
  uint8_t recorroTotal = 0;

  while (bool == 0 && recorroNombre < 5)
    {
      memcpy(&letra , directorioACrear + recorroTotal , sizeof(char));
      stNombreLargoAEscribir->LFN_NombreParte1 [recorroNombre] = letra;
      recorroNombre++;
      recorroTotal++;
      if (letra == 0)
        bool = 1;
    }
  recorroNombre = 0;

  while (bool == 0 && recorroNombre < 6)
    {
      memcpy(&letra , directorioACrear + recorroTotal , sizeof(char));
      stNombreLargoAEscribir->LFN_NombreParte2 [recorroNombre] = letra;
      recorroNombre++;
      recorroTotal++;
      if (letra == 0)
        bool = 1;
    }
  recorroNombre = 0;

  while (bool == 0 && recorroNombre < 2)
    {
      memcpy(&letra , directorioACrear + recorroTotal , sizeof(char));
      stNombreLargoAEscribir->LFN_NombreParte3 [recorroNombre] = letra;
      recorroNombre++;
      recorroTotal++;
      if (letra == 0)
        bool = 1;
    }
}
void cargarNombreCorto (stDirectoryTable *stDirAEscribir, char *directorioACrear)
{
  char letra = 1;
  uint8_t recorroNombre = 0;
  uint8_t largoArchivo = 0;
  uint8_t largoExtension = 0;
  char *extension=NULL;

  memset(stDirAEscribir->DT_FileName , '\0' ,
      sizeof (stDirAEscribir->DT_FileName));
  memset(stDirAEscribir->DT_Extension , '\0' ,
      sizeof (stDirAEscribir->DT_Extension));


  if (strrchr(directorioACrear , '.') != NULL)
    {
      extension = (strrchr(directorioACrear , '.')) + 1;
      largoExtension = strlen(extension);
      largoArchivo = strlen(directorioACrear) - largoExtension - 1; //El Punto que le saque a la extension pero forma parte
    }
  else
    largoArchivo = strlen(directorioACrear);
  if (largoArchivo > 8)
    {
      while (letra != 0 && recorroNombre < 6)
        {
          memcpy(&letra , directorioACrear + recorroNombre , sizeof(char));
          letra = toupper(letra);
          stDirAEscribir->DT_FileName [recorroNombre] = letra;
          recorroNombre++;
        }
      if (recorroNombre == 6)
        {
          stDirAEscribir->DT_FileName [recorroNombre] = '~';
          stDirAEscribir->DT_FileName [recorroNombre + 1] = '1';
        }
    }
  else
    {

      while (letra != 0 && recorroNombre < sizeof (stDirAEscribir->DT_FileName))
        {
          memcpy(&letra , directorioACrear + recorroNombre , sizeof(char));
          letra = toupper(letra);
          stDirAEscribir->DT_FileName [recorroNombre] = letra;
          recorroNombre++;
        }
      while (largoArchivo < sizeof (stDirAEscribir->DT_FileName))
        {
          stDirAEscribir->DT_FileName [largoArchivo] = 0x20;
          largoArchivo++;
        }
    }
  recorroNombre = 0;

  while (recorroNombre < 3)
    {
      if (extension == NULL)
        {
          stDirAEscribir->DT_Extension [recorroNombre] = 0x20;
        }
      else
        {
          memcpy(&letra , extension + recorroNombre , sizeof(char));
          stDirAEscribir->DT_Extension [recorroNombre] = toupper(letra);
        }
      recorroNombre++;
    }

}
void
crearEntradasDirectorio (stDirectoryTable *stDirAEscribir,
    stLongFileName *stNombreLargoAEscribir, char *nombre)
{
  uint16_t entradaVacia = -1;
  memset(stNombreLargoAEscribir->LFN_NombreParte1 , entradaVacia ,
      sizeof (stNombreLargoAEscribir->LFN_NombreParte1));
  memset(stNombreLargoAEscribir->LFN_NombreParte2 , entradaVacia ,
      sizeof (stNombreLargoAEscribir->LFN_NombreParte2));
  memset(stNombreLargoAEscribir->LFN_NombreParte3 , entradaVacia ,
      sizeof (stNombreLargoAEscribir->LFN_NombreParte3));
  cargarNombreLargo(stNombreLargoAEscribir , nombre);
  cargarNombreCorto(stDirAEscribir , nombre);
  stNombreLargoAEscribir->LFN_secuenceNumber = 0x41;
  stNombreLargoAEscribir->LFN_Atributos = NOMBRELARGO;
  stNombreLargoAEscribir->LFN_Reservados = 0x00;
  stNombreLargoAEscribir->LFN_CheckDOS = 0x1;
  stNombreLargoAEscribir->LFN_PrimerCluster = 0x0000;
}

void
traducirLittleEndian (uint32_t nroCluster, uint16_t *clusterHigh,
    uint16_t *clusterLow)
{

  *clusterHigh = (nroCluster & 0xFFFF);
  *clusterLow = ( (nroCluster >> 16) & 0xFFFF);

}

uint32_t
armarClusterInicial (uint16_t clusterHigh, uint16_t clusterLow)
{

  return ( (clusterHigh & 0xFFFF) << 16) | ( (clusterLow & 0xFFFF));
}

